.TH std::stack::swap 3 "2024.06.10" "http://cppreference.com" "C++ Standard Libary"
.SH NAME
std::stack::swap \- std::stack::swap

.SH Synopsis
   void swap( stack& other ) noexcept(/* see below */);  \fI(since C++11)\fP

   Exchanges the contents of the container adaptor with those of other. Effectively
   calls

 using std::swap;
 swap(c, other.c);

.SH Parameters

   other - container adaptor to exchange the contents with

.SH Return value

   \fI(none)\fP

.SH Exceptions

   noexcept specification:
   noexcept(noexcept(swap(c, other.c)))                                   \fI(since C++11)\fP
                                                                          \fI(until C++17)\fP
   In the expression above, the identifier swap is looked up in the same
   manner as the one used by the C++17 std::is_nothrow_swappable trait.
   noexcept specification:                                                \fI(since C++17)\fP
   noexcept(std::is_nothrow_swappable_v<Container>)

.SH Complexity

   Same as underlying container (typically constant).

.SH Notes

   Some implementations (e.g. libc++) provide the swap member function as an extension
   to pre-C++11 modes.

.SH Example


// Run this code

 #include <iostream>
 #include <concepts>
 #include <stack>
 #include <string>
 #include <string_view>
 #include <vector>

 template<typename Adaptor>
 requires (std::ranges::input_range<typename Adaptor::container_type>)
 void print(std::string_view name, const Adaptor& adaptor)
 {
     struct Printer : Adaptor // to use protected Adaptor::Container c;
     {
         void print(std::string_view name) const
         {
             std::cout << name << " [" << std::size(this->c) << "]: ";
             for (auto const& elem : this->c)
                 std::cout << elem << ' ';
             std::cout << '\\n';
         }
     };

     static_cast<Printer const&>(adaptor).print(name);
 }

 int main()
 {
     std::vector<std::string> v1{"1","2","3","4"},
                              v2{"Ɐ","B","Ɔ","D","Ǝ"};

     std::stack s1(std::move(v1));
     std::stack s2(std::move(v2));

     print("s1", s1);
     print("s2", s2);

     s1.swap(s2);

     print("s1", s1);
     print("s2", s2);
 }

.SH Output:

 s1 [4]: 4 3 2 1
 s2 [5]: Ǝ D Ɔ B Ɐ
 s1 [5]: Ǝ D Ɔ B Ɐ
 s2 [4]: 4 3 2 1

  Defect reports

   The following behavior-changing defect reports were applied retroactively to
   previously published C++ standards.

      DR    Applied to          Behavior as published           Correct behavior
   LWG 2456 C++11      the noexcept specification is ill-formed made to work

.SH See also

   std::swap(std::stack) specializes the std::swap algorithm
   \fI(C++11)\fP               \fI(function template)\fP

.SH Category:
     * conditionally noexcept
